home *** CD-ROM | disk | FTP | other *** search
/ BCI NET / BCI NET Dec 94.iso / archives / programming / languages / cleo.lzh / Cleo / source / VARS.C < prev   
Encoding:
C/C++ Source or Header  |  1993-01-24  |  22.1 KB  |  615 lines
  1. /***************************************************************************
  2. *   Ce fichier, ainsi que tous les  modules  l'accompagnant, peut et  doit *
  3. * etre  copié GRATUITEMENT à la seule condition expresse de conserver      *
  4. * l'INTEGRALITE  du  Code Source, de  la documentation, et  des fichiers   *
  5. * annexes du package. Ce logiciel est Shareware, veuilez envoyer 100 FF à  *
  6. * l'auteur pour recevoir regulièrement les nouvelles versions.             *
  7. * Toute modification est INTERDITE sans l'autorisation écrite de l'auteur. *
  8. *            Tous droits réservés à M. DIALLO Barrou, Juillet 1992.        *
  9. ***************************************************************************/
  10.  
  11. /************************* Traitements des Variables **********************/
  12. #include <string.h>
  13.  
  14. #ifdef msdos
  15.         #include "include\\cleobis.h"
  16. #else
  17.         #include "include/cleobis.h"
  18. #endif
  19.  
  20. extern void TraitErreur (char type, int num, int lig, int col);
  21. extern Erreur Erreurs[];
  22. extern Erreur Avertis[];
  23. extern int curlg;
  24. extern int curcol;
  25. extern char curtoken[];
  26. extern CONST *symb;
  27. extern CONST *cursymb;
  28. extern VAR *var;
  29. extern VAR *curvar;
  30. extern int NbVar;
  31. extern MY_TYPESID curtokentype;
  32. extern MY_TYPESID lasttokentype;
  33. extern MY_CONST curconst;
  34. extern Entete head;
  35. extern int curtokenid;
  36. extern int lasttokenid;
  37. extern int Nbfct;
  38. extern int curfct;
  39. extern FIELDSTRUCT Field[];
  40.  
  41. /******** Fonction qui insere une constante quelconque dans la liste ***/
  42.  
  43. void InsConst(void)              /*   MY_CONST + MY_TYPESID = SYMBOL    */
  44. {
  45.          CONST *new;
  46.  
  47.          if (!( new =(CONST *)calloc( sizeof(CONST), 1)))
  48.               TraitErreur(FATALERROR, MEMSYM, curlg, curcol);
  49.  
  50.     if (symb == NULL)
  51.         {
  52.          symb = new;
  53.          cursymb = new;
  54.         }
  55.     else
  56.         {
  57.         cursymb->next = new;
  58.         cursymb = new;
  59.         }
  60.  
  61.          new->type = curtokentype;
  62.     switch(curtokentype)
  63.      {
  64.         case constchr_mt:
  65.              new->variable.Char = curconst.Char ;    /* affecte la valeur */
  66.              new->num = head.Char;                   /* Son numero */
  67.              Code(PVAL_CHR, head.Char);             /* val du Nieme Char in Stack */
  68.              head.Char++;                            /* Un Char de plus */
  69.              break;
  70.  
  71.         case constint_mt:
  72.              new->variable.integer = curconst.integer ;
  73.              new->num = head.integer;
  74.              Code(PVAL_INT, head.integer);          /* val du Nieme Int in Stack */
  75.              head.integer++;
  76.              break;
  77.  
  78.         case conststr_mt:
  79.              strcpy( new->variable.string, curconst.string) ;
  80.              new->num = head.string;
  81.              Code(PVAL_STR, head.string);           /* Adr du Nieme String in Stack */
  82.              head.string++;
  83.              break;
  84.  
  85.         case constreal_mt:
  86.              new->variable.real = curconst.real ;
  87.              new->num = head.real;
  88.              Code(PVAL_REAL, head.real);            /* val du Nieme Real in Stack */
  89.              head.real++;
  90.              break;
  91.        default:
  92.             printf("Erreur dans la détection de la constante\n");
  93.             End(); exit(); break;
  94.      }
  95.     new->next = NULL;
  96.     Lexical();
  97. }
  98.  
  99. void ListConst(void)
  100. {
  101.          CONST *cur=symb;
  102.  
  103.     while (cur !=NULL)
  104.     {
  105.         switch(cur->type)
  106.         {
  107.         case constchr_mt:
  108.             printf("char N°%d:<%c>\n",cur->num, cur->variable.Char);
  109.              break;
  110.         case constint_mt:
  111.             printf("integer N°%d:<%d>\n",cur->num, cur->variable.integer);
  112.              break;
  113.         case conststr_mt:
  114.             printf("string N°%d:<%s>\n",cur->num, cur->variable.string);
  115.              break;
  116.         case constreal_mt:
  117.             printf("real N°%d:<%f>\n",cur->num, cur->variable.real);
  118.              break;
  119.         default:
  120.             printf("Defaut d'acquisition de la constante\n");
  121.               End(); exit(); break;
  122.              break;
  123.         }
  124.         cur = cur->next;
  125.     }
  126. }
  127.  
  128. void Assign(void)
  129. {
  130.         int type=-1;           /* type de la variable a assigner */
  131.  
  132.         if (curtokenid != ident_mt)
  133.                 TraitErreur( TEXTERROR, NOIDENT, curlg, curcol);
  134.         else
  135.         {
  136.            type = TestVar(FALSE);       /* Test et load adr in stack */
  137.  
  138.                if (curtokenid != affecte_b)
  139.                         TraitErreur (TEXTERROR, NOAFFECTE, curlg, curcol);
  140.                 else
  141.                 {
  142.                         Lexical();
  143.                         Simple_Exp();
  144.  
  145. /* ici on a le resultat, reste à l'assigner a la variable d'un certain type */
  146.  
  147.                         switch( type)
  148.                             {
  149.                              case integer_t:
  150.                                 Code(STM_INT, 0); /* charge la valeur de la pile
  151.                                               à la variable dont l'adr est a pile-1 */
  152.                                break;
  153.                              case longint_t:
  154.                                 Code(STM_LINT, 0);   break;
  155.                              case real_t:
  156.                                  Code(STM_REAL, 0);  break;
  157.                              case longreal_t:
  158.                                  Code(STM_LREAL, 0);  break;
  159.                              case string_t:
  160.                                  Code(STM_STR, 0);   break;
  161.                              case char_t:
  162.                                  Code(STM_CHR, 0);   break;
  163.                              case boolean_t:
  164.                                  Code(STM_BOOL, 0);  break;
  165.                              case array_t:
  166.                                  Code(STM_ARRAY, 0);     break;
  167.                              case point2d_t:
  168.                                  Code(STM_P2D, 0);     break;
  169.                              case point3d_t:
  170.                                  Code(STM_P3D, 0);     break;
  171.                              case rgb_t:
  172.                                  Code(STM_RGB, 0);     break;
  173.                              default:
  174.                               printf ("*** internal: Variable de type inconnu ASSIGN \n");
  175.                                End(); exit(); break;
  176.                 }
  177.  
  178.                 }
  179.         }
  180. }
  181.  
  182. void InsVar(void)
  183. {
  184.         VAR *new, *idx=var;
  185.         BOOL fin=FALSE;
  186.  
  187.          if (!( new =(VAR *)calloc( sizeof(VAR), 1)))
  188.             TraitErreur(FATALERROR, MEMSYM, curlg, curcol);
  189.         NbVar++;
  190.          if (var == NULL)
  191.             {
  192.                 var = new;
  193.                 curvar = new;
  194.                 new->prev = NULL;
  195.             }
  196.          else
  197.             {
  198.                 while( idx !=NULL && !fin)
  199.                     {
  200.  
  201.                         if ( !strcmp(idx->str, curtoken) && curfct==idx->fct) fin=TRUE;
  202.                         else
  203.                              idx = idx->next;
  204.                     }
  205.                 if (fin)
  206.                       TraitErreur(TEXTERROR, DOUBLESYMB, curlg,curcol);
  207.                 else
  208.                     {
  209.                         curvar->next = new;
  210.                         new->prev = curvar;
  211.                         curvar = new;
  212.                     }
  213.             }
  214.         strcpy(new->str, curtoken);         /* Copie le Nom */
  215.         new->next = NULL;
  216.         Lexical();
  217. }
  218.  
  219. /*** Fct qui assigne un type aux n dernieres variables de la liste */
  220. /*** Leur affecte un numero suivant leur type ***/
  221.  
  222. void AssignType(int n, int type, int borne1, int borne2, int typet)
  223. {
  224.     VAR *idx= curvar;
  225.  
  226.     while (n--)
  227.         {
  228.          idx->type = type;
  229.          idx -> fct =curfct ;        /* Numero de la fct auquel elle E */
  230.          switch(type)
  231.             {
  232.                 case integer_t:
  233.                    idx->num= head.Vinteger++;    break;
  234.                 case longint_t:
  235.                    idx->num= head.Vlongint++;    break;
  236.                 case real_t:
  237.                    idx->num= head.Vreal++;       break;
  238.                 case longreal_t:
  239.                    idx->num= head.Vlongreal++;   break;
  240.                 case string_t:
  241.                    idx->num= head.Vstring++;     break;
  242.                 case char_t:
  243.                    idx->num= head.Vchar++;       break;
  244.                 case boolean_t:
  245.                    idx->num= head.Vboolean++;    break;
  246.                 case array_t:
  247.                    idx->num= head.Varray++;
  248.                    idx->tab.borne1 = borne1;  /* copie les donnees du Tab */
  249.                    idx->tab.borne2 = borne2;
  250.                    idx->tab.type   = typet;   /* Type du tableau */
  251.                    break;
  252.                 case point2d_t:
  253.                    idx->num= head.Vpoint2d++;    break;
  254.                 case point3d_t:
  255.                    idx->num= head.Vpoint3d++;    break;
  256.                 case rgb_t:
  257.                    idx->num= head.Vrgb++;    break;
  258.             }
  259.         idx=idx->prev;
  260.         }
  261. }
  262.  
  263. void ListVar(void)
  264. {
  265.          VAR *list=var;
  266.          printf("\n");
  267.          while(list != NULL)
  268.          {
  269.                 printf("\tFonction <%d> Variable No%d = <%s>\ttype: ",list->fct, list->num, list->str);
  270.                 switch(list->type)
  271.                 {
  272.                 case integer_t:
  273.                             printf("Integer\n"); break;
  274.                 case longint_t:
  275.                             printf("LongInt\n"); break;
  276.                 case real_t:
  277.                             printf("Real\n"); break;
  278.                 case longreal_t:
  279.                             printf("LongReal\n"); break;
  280.                 case string_t:
  281.                             printf("String\n"); break;
  282.                 case char_t:
  283.                             printf("Char\n"); break;
  284.                 case boolean_t:
  285.                             printf("Boolean\n"); break;
  286.                 case array_t:
  287.                             printf("Array\n"); break;
  288.                 case point2d_t:
  289.                             printf("Point2d\n"); break;
  290.                 case point3d_t:
  291.                             printf("Point3d\n"); break;
  292.                 case rgb_t:
  293.                             printf("rgb\n"); break;
  294.                 default:
  295.                             printf ("*** Variable de type inconnu\n");   break;
  296.                                                                                                                                         End(); exit(); break;
  297.                 }
  298.            list = list->next;
  299.          }
  300. }
  301.  
  302. void Gere_Variable(void)
  303. {
  304.     int n=0;
  305.     int borne1=0, borne2=0, typet=0;
  306.  
  307.     Lexical();
  308.     if (curtokentype != ident_mt)
  309.         TraitErreur( TEXTERROR, NOIDENT, curlg, curcol);
  310.     while (curtokentype == ident_mt)
  311.     {
  312.         n=0;
  313.         while (curtokentype == ident_mt)
  314.         {
  315.             InsVar(); n++;
  316.             if ( *curtoken == ',')
  317.                 {
  318.                     Lexical();
  319.                     if (curtokentype != ident_mt)
  320.                         TraitErreur( TEXTERROR, NOIDENT, curlg, curcol);
  321.                 }
  322.          }
  323.          if ( *curtoken != ':')
  324.                 TraitErreur( TEXTERROR, NOPP, curlg, curcol);
  325.          Lexical();
  326.          if (curtokentype != reservedtype_mt)
  327.             TraitErreur( TEXTERROR, NOTYPE, curlg, curcol);
  328.          if (curtokenid == array_t)              /*** Type Tableau ***/
  329.             {
  330.              Lexical();
  331.              if (*curtoken != '[')       /*** Ne gere pas les Ensembles ***/
  332.                 TraitErreur( TEXTERROR, NOBRAKETO, curlg, curcol);
  333.              Lexical();                 /* 1ere Borne */
  334.              if (curtokentype == constchr_mt || curtokentype == constint_mt )
  335.               {
  336.                 /* Que les constantes INT ou CHAR ex: [1..6] ou ['r'..'z'] */
  337.  
  338.                 switch( curtokentype)
  339.                     {
  340.                     case constchr_mt:
  341.                         borne1 = (int)curconst.Char ;    /* affecte la valeur */
  342.                         break;
  343.                     case constint_mt:
  344.                         borne1 = (int) curconst.integer ;
  345.                         break;
  346.                     }
  347.               }
  348.              else
  349.                 TraitErreur( TEXTERROR, NOCONST, curlg, curcol);
  350.              Lexical();
  351.             if (curtokentype == reserved_mt && curtokenid == pp_f)
  352.               {
  353.                 Lexical();    /* Lit la 2ieme Borne */
  354.                 if (curtokentype == constchr_mt || curtokentype == constint_mt )
  355.                     {
  356.                         switch( curtokentype)
  357.                         {
  358.                         case constchr_mt:
  359.                             borne2 = (int)curconst.Char ;    /* affecte la valeur */
  360.                             break;
  361.                         case constint_mt:
  362.                             borne2 = (int) curconst.integer ;
  363.                             break;
  364.                         }
  365.                     }
  366.                 else
  367.                     TraitErreur( TEXTERROR, NOCONST, curlg, curcol);
  368.               }
  369.             else
  370.                 TraitErreur( TEXTERROR, SEPPP, curlg, curcol);
  371.             Lexical();
  372.             if (*curtoken != ']')
  373.                 TraitErreur( TEXTERROR, NOBRAKETF, curlg, curcol);
  374.             Lexical();
  375.             if ( curtokenid != of_f)
  376.                 TraitErreur( TEXTERROR, NOOF, curlg, curcol);
  377.             Lexical();
  378.             if (curtokenid == char_t || curtokenid == real_t ||
  379.              curtokenid == integer_t ||  curtokenid == string_t ||
  380.              curtokenid ==boolean_t ||  curtokenid ==longint_t||
  381.              curtokenid ==longreal_t ||  curtokenid ==point2d_t ||
  382.              curtokenid ==point3d_t || curtokenid ==rgb_t)
  383.                     typet = curtokenid ;           /*type du tableau */
  384.             else
  385.                 TraitErreur( TEXTERROR, NOTYPE, curlg, curcol);
  386.             curtokenid= array_t;
  387.             }
  388.          AssignType(n, curtokenid, borne1, borne2, typet);
  389.          Lexical();
  390.          if ( *curtoken != ';')
  391.             TraitErreur( TEXTERROR, NOVIRG, curlg, curcol);
  392.          Lexical();
  393.     }
  394. }
  395.  
  396. /* Fct qui met l'adresse d'une variable dans la pile */
  397. /* Si load = TRUE alors elle charge apres sa valeur dans la pile */
  398. /* Retourne le type de la var */
  399.  
  400. int TestVar(BOOL load)
  401. {
  402.          VAR *list=var;
  403.          BOOL fin=FALSE, trouve=FALSE;
  404.          int n=0, indice, typ;
  405.          FIELDSTRUCT *champ= Field;
  406.          char *adr;
  407.  
  408.       while(list != NULL && !fin)
  409.        {
  410.          if (!(strcmp(curtoken, list->str)) && (list->fct== curfct || list->fct==0)) fin=TRUE;
  411.          else
  412.          list = list->next;
  413.        }
  414.      if (fin)
  415.       {
  416.         switch(list->type)
  417.              {
  418.                 case integer_t:
  419.                           Code (PADR_INT, list->num);
  420.                           if (load) Code(PMEM_INT, list->num);
  421.                           break;
  422.                 case longint_t:
  423.                           Code (PADR_LINT, list->num);
  424.                           if (load) Code(PMEM_LINT, list->num);
  425.                           break;
  426.                 case real_t:
  427.                           Code (PADR_REAL, list->num);
  428.                           if (load) Code(PMEM_REAL, list->num);
  429.                           break;
  430.                 case longreal_t:
  431.                           Code (PADR_LREAL, list->num);
  432.                           if (load) Code(PMEM_LREAL, list->num);
  433.                           break;
  434.                 case string_t:
  435.                           Code (PADR_STR, list->num);
  436.                           if (load) Code(PMEM_STR, list->num);
  437.                           break;
  438.                 case char_t:
  439.                           Code (PADR_CHR, list->num);
  440.                           if (load) Code(PMEM_CHR, list->num);
  441.                           break;
  442.                 case boolean_t:
  443.                           Code (PADR_BOOL, list->num);
  444.                           if (load) Code(PMEM_BOOL, list->num);
  445.                           break;
  446.                 case array_t:
  447.                          Code (PADR_ARRAY, list->num);
  448.  
  449.                         Lexical();
  450.                         if ( *curtoken != '[')
  451.                            TraitErreur( TEXTERROR, NOBRAKETO, curlg, curcol);
  452.                         Lexical();
  453.                         Simple_Exp();       /* lit l'index */
  454.                         if ( *curtoken != ']')
  455.                             TraitErreur( TEXTERROR, NOBRAKETF, curlg, curcol);
  456.                             /* etat de la pile : Tab_adr - index -   */
  457.  
  458.                     typ = list->tab.type;
  459.                     if (typ == point3d_t || typ == point2d_t || typ == rgb_t)
  460.                       {
  461.                         Lexical();
  462.                         if ( *curtoken != '.')
  463.                          {
  464.  
  465.                          }
  466.                         Lexical();
  467.                         n=0; fin=FALSE; trouve=FALSE;
  468.                         while ( !fin && !trouve)
  469.                          {
  470.                             if (champ[n].id == typ)
  471.                                 trouve=TRUE;
  472.                             else
  473.                             if (champ[n].id == fin_t)
  474.                                 fin=TRUE;
  475.                             else  n++;
  476.                          }
  477.                         if (fin)
  478.                             {
  479.                                 printf("*** Internal error : type_id not found\n");
  480.                                 End(); exit();
  481.                             }
  482.                        if (!(adr = (char *)strchr(champ[n].str, (int)*curtoken) ))
  483.                             TraitErreur( TEXTERROR, UNFIELD, curlg, curcol);
  484.                        else
  485.                         {
  486.                             indice =(int)(adr - champ[n].str); /* calcul le No du champ */
  487.                         /* indice correspond a l'indice du champ */
  488.  /* indice <0 */           Code ( PUSHVAL, -indice-1); /* push neg (nbre indice)-1 pour le differencier  d'un index de tableau */
  489.                         }
  490.                       }
  491.                        if (load) Code(PMEM_ARRAY, list->num);
  492.                        break;
  493.  
  494.                 case point3d_t:
  495.                     Code (PADR_P3D, list->num);
  496.  
  497.                     Lexical();
  498.                     if ( *curtoken != '.')
  499.                      {
  500.                        if (load) Code(PMEM_P3D_ALL, list->num);
  501.                        return( list->type);
  502.                      }
  503.  
  504.                     Lexical();
  505.                     n=0; fin=FALSE; trouve=FALSE;
  506.                     while ( !fin && !trouve)
  507.                     {
  508.                         if (champ[n].id == (int) point3d_t)
  509.                             trouve=TRUE;
  510.                         else
  511.                         if (champ[n].id == fin_t)
  512.                             fin=TRUE;
  513.                         else  n++;
  514.                     }
  515.                     if (fin)
  516.                         {
  517.                          printf("*** Internal error : type_id not found\n");
  518.                          End(); exit();
  519.                         }
  520. /*pas pour UNIX */      if (!(adr = (char *)strchr(champ[n].str, (int)*curtoken) ))
  521.                         TraitErreur( TEXTERROR, UNFIELD, curlg, curcol);
  522.                     else
  523.                     {
  524.                         indice =(int)(adr - champ[n].str); /* calcul le No du champ */
  525.                         /* indice correspond a l'indice du champ */
  526.                     Code ( PUSHVAL, indice);     /* met le nbre indice dans la pile */
  527.                     if (load) Code(PMEM_P3D, list->num);
  528.                     }
  529.                     break;
  530.  
  531.                 case point2d_t:
  532.                          Code (PADR_P2D, list->num);
  533.  
  534.                         Lexical();
  535.                         if ( *curtoken != '.')
  536.                             {
  537.                             if (load) Code(PMEM_P2D_ALL, list->num);
  538.                             return( list->type);
  539.                             }
  540.                         Lexical();
  541.  
  542.                     n=0; fin=FALSE; trouve=FALSE;
  543.                     while ( !fin && !trouve)
  544.                     {
  545.                         if (champ[n].id == (int) point2d_t)
  546.                             trouve=TRUE;
  547.                         else
  548.                         if (champ[n].id == fin_t)
  549.                             fin=TRUE;
  550.                         else  n++;
  551.                     }
  552.                     if (fin)
  553.                         {
  554.                          printf("*** Internal error : type_id not found\n");
  555.                          End(); exit();
  556.                         }
  557.                      if (!(adr = (char *)strchr(champ[n].str, (int)*curtoken) ))
  558.                         TraitErreur( TEXTERROR, UNFIELD, curlg, curcol);
  559.                     else
  560.                     {
  561.                         indice =(int)(adr - champ[n].str); /* calcul le No du champ */
  562.                         /* indice correspond a l'indice du champ */
  563.                     Code ( PUSHVAL, indice);     /* met le nbre indice dans la pile */
  564.                     if (load) Code(PMEM_P2D, list->num);
  565.                     }
  566.                     break;
  567.  
  568.                 case rgb_t:
  569.                     Code (PADR_RGB, list->num);
  570.  
  571.                     Lexical();
  572.                     if ( *curtoken != '.')
  573.                      {
  574.                        if (load) Code(PMEM_RGB_ALL, list->num);
  575.                        return( list->type);
  576.                      }
  577.  
  578.                     Lexical();
  579.                     n=0; fin=FALSE; trouve=FALSE;
  580.                     while ( !fin && !trouve)
  581.                     {
  582.                         if (champ[n].id == (int) rgb_t)
  583.                             trouve=TRUE;
  584.                         else
  585.                         if (champ[n].id == fin_t)
  586.                             fin=TRUE;
  587.                         else  n++;
  588.                     }
  589.                     if (fin)
  590.                         {
  591.                          printf("*** Internal error : type_id not found\n");
  592.                          End(); exit();
  593.                         }
  594.                       if (!(adr = (char *)strchr(champ[n].str, (int)*curtoken) ))
  595.                         TraitErreur( TEXTERROR, UNFIELD, curlg, curcol);
  596.                     else
  597.                     {
  598.                         indice =(int)(adr - champ[n].str); /* calcul le No du champ */
  599.                         /* indice correspond a l'indice du champ */
  600.                     Code ( PUSHVAL, indice);     /* met le nbre indice dans la pile */
  601.                     if (load) Code(PMEM_RGB, list->num);
  602.                     }
  603.                     break;
  604.  
  605.  
  606.                 default:
  607.                     printf ("*** Variable de type inconnu\n");
  608.                     End(); exit(); break;
  609.             }
  610.           Lexical();
  611.           return( list->type);
  612.       }
  613.       else
  614.          TraitErreur(TEXTERROR, UNKNOWNVAR, curlg, curcol);
  615. }